Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/components/rightSidePanel/errors/useErrorGroups.ts`:
- Around line 615-623: The title is using
missingModelStore.missingModelCandidates?.length which counts raw candidates
instead of grouped items; update buildMissingModelGroups() to use the grouped
collection (missingModelGroups.value.length or the grouped array produced by
groupCandidatesByName) for the count in the title so the displayed number
matches the collapsed rows (reference function buildMissingModelGroups and the
reactive missingModelGroups.value).

In `@src/platform/missingModel/components/MissingModelCard.test.ts`:
- Around line 22-38: The test stubbed i18n (const i18n) lacks the
rightSidePanel.missingModels.unknownCategory translation so the test only
matches the raw key; add an entry under messages.en.rightSidePanel.missingModels
like unknownCategory: 'Expected Label' and then update the assertion in
MissingModelCard.test.ts (where it currently checks for the substring
"unknownCategory") to assert the rendered text equals or contains the translated
string instead of the key; search for the literal "unknownCategory" in the test
to find and replace the assertion and ensure the component uses the i18n
instance in the test render.

In `@src/platform/missingModel/components/MissingModelUrlInput.vue`:
- Around line 151-153: The template uses canImportModels but it’s assigned from
flags.privateModelsEnabled which is reactive and can change later; wrap the
access in a computed so the template remains reactive: replace the plain const
canImportModels = flags.privateModelsEnabled with a computed(()=>
flags.privateModelsEnabled) (keep useFeatureFlags and useModelUpload usage
as-is) so the component reads the reactive flag instead of a frozen snapshot.

In `@src/platform/missingModel/composables/useMissingModelInteractions.test.ts`:
- Around line 132-136: The test setup in the beforeEach block uses
vi.clearAllMocks(), which only clears call history and leaks module-scoped mock
implementations like mockDownloadList and mockGetNodeByExecutionId across tests;
replace vi.clearAllMocks() with vi.resetAllMocks() in the beforeEach (the block
that also calls setActivePinia(createPinia()) and sets app.rootGraph) so that
both call history and mock implementations are reset between tests.

In `@src/platform/missingModel/composables/useMissingModelInteractions.ts`:
- Around line 192-210: The store.importCategoryMismatch flag is never cleared
when the user changes the URL or retries an import, leaving
isSelectionConfirmable() blocked; update handleUrlInput to clear
store.importCategoryMismatch[key] (e.g., delete
store.importCategoryMismatch[key] or set it false) when the URL is edited before
setting the debounce timer and also clear the same flag at the start of the
import flow where fetchUrlMetadata or the import-start function is invoked so
every new fetch/import attempt resets importCategoryMismatch.
- Around line 204-245: The fetchUrlMetadata flow can still update
store.urlMetadata, store.urlErrors, or selectedLibraryModel after the input has
changed; add a per-key request token or AbortSignal tied to the debounce key
(the same key used in store.setDebounceTimer) and check it before mutating state
in fetchUrlMetadata (and likewise in uploadAssetAsync handlers around
assetService.getAssetMetadata and uploadAssetAsync results). Generate and store
a unique token/abort controller when scheduling the debounce, pass/attach it to
the async call, and on any new edit/cancel/clear replace/abort the token; before
writing to store.urlMetadata, store.urlErrors, or selectedLibraryModel verify
the token/signal still matches/not aborted and skip updates if stale.
- Around line 177-189: When applying the selected model in the loop that uses
getNodeByExecutionId and referencingNodes, don't just set widget.value; invoke
the widget's normal mutation path by calling widget.callback?.(value) (or the
same call signature used elsewhere) immediately after setting widget.value so
the node's internal logic runs, and ensure the graph is marked dirty/modified
via the same mutation/dirtying flow used elsewhere before calling
store.removeMissingModelByNameOnNodes; in short, for each found widget call
widget.callback?.(value) and trigger the graph-modified/dirty mutation prior to
removing the missing-model entry.

In `@src/platform/missingModel/missingModelScan.ts`:
- Around line 162-187: The enrichment map is keyed only by name
(candidatesByName), causing cross-directory collisions; change the key to
include directory as well (e.g. use `${c.name}::${c.directory ?? ''}` when
inserting into candidatesByName and when looking up from embeddedModels use
`${model.name}::${model.directory ?? ''}`), and optionally keep a fallback
name-only lookup if you need backward compatibility (check
candidatesByName.get(`${model.name}::${model.directory ?? ''}`) first, then
candidatesByName.get(model.name) if not found) so each same-named file in
different directories is matched to the correct embedded model before applying
the `??=` assignments.
- Around line 286-316: The function verifyAssetSupportedCandidates currently
waits until after importing the assets store and after each
updateModelsForNodeType call to check signal.aborted, causing wasted work for
aborted workflows; fix it by checking signal?.aborted immediately after
computing pendingNodeTypes and before importing the assets store (abort early),
and also check signal?.aborted inside the per-nodeType loop before calling
store.updateModelsForNodeType(nodeType) to skip refreshes for already-aborted
signals; keep using the provided assetsStore fallback logic and preserve the
existing try/catch around updateModelsForNodeType.

In `@src/platform/workflow/validation/schemas/workflowSchema.ts`:
- Around line 603-610: graphData.definitions?.subgraphs only collects top-level
subgraph definitions so nested subgraph definitions are omitted; replace direct
usage of graphData.definitions?.subgraphs when building pathMap and
subgraphDefMap with a recursive collector (e.g., collectSubgraphDefinitions)
that walks candidate.definitions?.subgraphs and deduplicates by id using
isSubgraphDefinition; then pass the returned flattened array into
buildSubgraphExecutionPaths(rootNodes, collectedSubgraphs) and use it to
construct subgraphDefMap (map by s.id) so nested subgraphs and their nodes are
included in missing-model detection.

In `@src/stores/executionErrorStore.ts`:
- Around line 98-106: The clearAllErrors() function currently calls
missingModelStore.clearMissingModels(), which wipes in-progress missing-model
resolution state; remove the call to missingModelStore.clearMissingModels() from
clearAllErrors() so it only resets UI/error state (lastExecutionError,
lastPromptError, lastNodeErrors, missingNodesError, isErrorOverlayOpen) and do
not touch missing model importTaskIds/URL/importing flags here; keep the full
missingModelStore.clearMissingModels() only in workflow-load/clean/explicit
reset code paths (where workflow changes are handled) rather than in
clearAllErrors().

---

Outside diff comments:
In `@src/renderer/extensions/vueNodes/components/LGraphNode.vue`:
- Around line 343-358: The missing-model check is using the full nodeLocatorId
(which includes subgraph path) but the missingModelStore keys by raw node IDs,
so subgraph leaf nodes miss the error state; change the call(s) that pass
nodeLocatorId.value to missingModelStore to use the raw node id (nodeData.id)
instead—specifically update
missingModelStore.hasMissingModelOnNode(nodeLocatorId.value) to
missingModelStore.hasMissingModelOnNode(nodeData.id) (and any other
missingModelStore lookups here that currently receive nodeLocatorId.value) so
lookups match the store's keying.

---

Nitpick comments:
In `@src/components/rightSidePanel/errors/useErrorGroups.test.ts`:
- Around line 50-55: Remove the unused vi.mock call for
'@/platform/missingModel/composables/useMissingModelInteractions' from the
useErrorGroups.test.ts file because useErrorGroups() does not import or exercise
that composable; specifically delete the vi.mock(...) block that returns
clearMissingModelState and confirm no other test helpers reference
clearMissingModelState, then run the tests to ensure nothing else depended on
that fake dependency.

In `@src/platform/missingModel/missingModelScan.test.ts`:
- Around line 939-948: Extend the test for verifyAssetSupportedCandidates so it
asserts the expensive work path (updateModelsForNodeType) is not invoked when
the signal is already aborted: arrange a spy or mock on updateModelsForNodeType
(or replace it with a function that would return a slow promise/throw if
called), create the aborted AbortController, call
verifyAssetSupportedCandidates(candidates, controller.signal), then assert the
spy was not called and candidates[0].isMissing is still undefined; this ensures
the implementation returns early and does not start the expensive
updateModelsForNodeType work.

In `@src/stores/executionErrorStore.test.ts`:
- Around line 21-26: Remove the dead mock for
'@/platform/missingModel/composables/useMissingModelInteractions' introduced via
vi.mock that provides clearMissingModelState; delete that vi.mock block and any
references to clearMissingModelState in the test file
(executionErrorStore.test.ts) so the test no longer stubs a non-existent export
or creates a fake dependency surface, and run the tests to confirm no remaining
imports or usages of useMissingModelInteractions remain.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/components/rightSidePanel/errors/useErrorGroups.ts`:
- Around line 574-623: The missing-model rows aren't being filtered by the
errors search because the computed missingModelGroups (used by TabErrors.vue /
MissingModelCard) always returns the full list; update useErrorGroups to derive
a query-filtered collection (e.g., filteredMissingModelGroups) by applying the
same search logic used for filteredGroups to the groupCandidates/models produced
in missingModelGroups, then have buildMissingModelGroups use that filtered
collection instead of missingModelGroups.value; reference the existing computed
missingModelGroups, the grouping step that calls groupCandidatesByName, and
buildMissingModelGroups so you can reuse or mirror the same query
predicate/filter function to narrow rows based on the current search query.

In `@src/platform/missingModel/missingModelScan.ts`:
- Around line 315-336: When updateModelsForNodeType(nodeType) throws during the
Promise.allSettled stage you must record that nodeType as failed and avoid
classifying any candidates for it; modify the concurrent map over
[...pendingNodeTypes] to add failing nodeTypes into a Set (e.g.,
failedNodeTypes) inside the catch block instead of just logging, then in the
downstream loop over candidates (the for loop using candidates, getAssets, and
isAssetInstalled) skip setting c.isMissing for any candidate whose c.nodeType is
in failedNodeTypes (leave c.isMissing undefined) and preserve the existing
signal?.aborted checks.

---

Duplicate comments:
In `@src/platform/missingModel/composables/useMissingModelInteractions.ts`:
- Around line 196-215: In handleUrlInput, invalidate any in-flight fetch token
so old responses can't repopulate state: before clearing row state
(store.urlMetadata/urlErrors/selectedLibraryModel) set or replace the per-key
request token in the store's _requestTokens map (the same slot fetchUrlMetadata
normally sets) to a fresh/neutral value so previous tokens are considered stale;
this ensures any older response handlers (which check _requestTokens[key]) will
bail out immediately when the URL changes and only the new fetch started by
fetchUrlMetadata can update urlMetadata/urlErrors/selectedLibraryModel.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/platform/missingModel/missingModelScan.ts`:
- Around line 203-236: The current Promise.allSettled drops models when
checkModelInstalled throws; change the mapping inside unmatched.map in
missingModelScan.ts so that instead of letting checkModelInstalled rejection
bubble, you catch errors locally and return a MissingModelCandidate that
preserves the model info and marks the install check as unresolved (e.g.,
isMissing: undefined) plus an installCheckError field (or similar optional
field) containing the caught error; keep using the existing symbols (unmatched,
checkModelInstalled, isAssetSupported, MissingModelCandidate, enriched) so the
loop can still push non-null values and the failed checks surface to the caller
instead of being skipped.

---

Duplicate comments:
In `@src/platform/missingModel/missingModelScan.ts`:
- Around line 310-313: Add a second abort check immediately before the dynamic
import to avoid loading assetsStore for an abandoned workflow: after the
existing pendingNodeTypes.size === 0 return and before the line that sets store
via assetsStore ?? (await import(...)).useAssetsStore(), check if
signal?.aborted and return early if true. This uses the same signal reference
used earlier in missingModelScan.ts and prevents importing
'@/stores/assetsStore' when the operation was cancelled.
- Around line 362-385: groupCandidatesByName currently keys groups only by
c.name which merges candidates from different directories; change the grouping
key to include the candidate directory (e.g. combine c.directory or a sentinel
for null/unsupported with c.name) so each distinct directory+name pair gets its
own MissingModelViewModel. Ensure the map key construction and lookup use that
combined key, and when creating the group (in the else branch) pick the
representative and initial referencingNodes from that candidate as now so
metadata/nodeType remains correct per directory group.